{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用了-net5 网络结构 去训练mnist数据集"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实现要点"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 网络结构\n",
    "- 卷积参数\n",
    "- 层数\n",
    "- 分类数量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/hadoop/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/base.py:198: retry (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use the retry module or similar alternatives.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-441013600715>:2: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From /home/hadoop/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From /home/hadoop/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From /home/hadoop/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /home/hadoop/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /home/hadoop/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784)\n",
      "(55000, 10)\n",
      "(5000, 784)\n",
      "(5000, 10)\n",
      "(10000, 784)\n",
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "#看看数据长什么样子\n",
    "mnist = input_data.read_data_sets(\"./\",one_hot=True)\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f3626c83b70>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#把图片打印出来\n",
    "plt.figure(figsize=(8,8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4,4,idx+1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(np.argmax(mnist.train.labels[idx])))\n",
    "    plt.imshow(mnist.train.images[idx].reshape(28,28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#定义网络的输入placeholder\n",
    "#28*28\n",
    "x = tf.placeholder(\"float\",[None,784],name='x')\n",
    "y = tf.placeholder(\"float\",[None,10],name='y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#把原本的一维向量还原成28×28×1的图片 tf.reshape()\n",
    "x_image = tf.reshape(x,[-1,28,28,1])#-1代表bachsize 自动计算的意思"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 网络结构的定义"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#卷积层slim方式\n",
    "#6个5×5卷积核，padding方式为valid，则输出数据的宽高变成24×24,深度从原来的1变成6,本层激活函数变成relu\n",
    "with tf.name_scope('conv1'):\n",
    "    C1 = tf.contrib.slim.conv2d(\n",
    "        x_image,6,[5,5],padding='VALID',activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#接着进行stride=2的最大池化，池化后，输出深度不变，但是长宽减半，则输出变为12×12×6\n",
    "with tf.name_scope('pool1'):\n",
    "    S2 = tf.contrib.slim.max_pool2d(C1,[2,2],stride=2,padding='VALID')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#16个5×5卷积核，padding方式为valid，则输出数据的宽高变成8*8,深度变成16,本层激活函数变成relu\n",
    "with tf.name_scope('conv2'):\n",
    "    C3 = tf.contrib.slim.conv2d(\n",
    "        S2,16,[5,5],padding='VALID',activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 再进行一次最大池化 结果4×4×16\n",
    "with tf.name_scope('pool2'):\n",
    "    S4 = tf.contrib.slim.max_pool2d(C3,[2,2],stride=2,padding='VALID')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#池化后的数据数3维的 加上bachsize是四维的  展开成一维的数据 加上bachsize一共是2维\n",
    "#然后送入两层全连接层 这两层神经元个数分别为120，84\n",
    "with tf.name_scope('fc1'):\n",
    "    S4_flat = tf.contrib.slim.flatten(S4)#展开成一维\n",
    "    C5 = tf.contrib.slim.fully_connected(S4_flat,120,activation_fn=tf.nn.relu)\n",
    "with tf.name_scope('fc2'):\n",
    "    F6 = tf.contrib.slim.fully_connected(C5,84,activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dropout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#对特征添加了一个0.6的dropout，以40%的概率丢弃特征中的某些数据\n",
    "#这样可提高网络的推广能力，减少过拟合的可能性\n",
    "#需要注意的是，dropout仅在训练的时候使用，验证的时候需要关闭dropout 所以验证时候的keep_prob=1.0\n",
    "#dropout的输出最终送入一个还有10个神经元的全连接层，这个全连接层就是最后的分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#dropout \n",
    "with tf.name_scope('dropout'):\n",
    "    keep_prob = tf.placeholder(name='keep_prob',dtype=tf.float32)\n",
    "    F6_drop = tf.nn.dropout(F6,keep_prob)\n",
    "    \n",
    "#输出层\n",
    "with tf.name_scope('fc3'):\n",
    "    logits = tf.contrib.slim.fully_connected(F6_drop,10,activation_fn=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loss函数 +Softmax激活"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 网络优化器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#先对未经激活的输出进行softmax计算 再计算交叉熵损失 写在一起会优化计算 tf.reduce_maen是对bach进行平均\n",
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.sigmoid_cross_entropy_with_logits(logits=logits,labels=y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 正则化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conv/weights:0\n",
      "INFO:tensorflow:Summary name Conv/weights:0 is illegal; using Conv/weights_0 instead.\n",
      "Conv/biases:0\n",
      "INFO:tensorflow:Summary name Conv/biases:0 is illegal; using Conv/biases_0 instead.\n",
      "Conv_1/weights:0\n",
      "INFO:tensorflow:Summary name Conv_1/weights:0 is illegal; using Conv_1/weights_0 instead.\n",
      "Conv_1/biases:0\n",
      "INFO:tensorflow:Summary name Conv_1/biases:0 is illegal; using Conv_1/biases_0 instead.\n",
      "fully_connected/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected/weights:0 is illegal; using fully_connected/weights_0 instead.\n",
      "fully_connected/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected/biases:0 is illegal; using fully_connected/biases_0 instead.\n",
      "fully_connected_1/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/weights:0 is illegal; using fully_connected_1/weights_0 instead.\n",
      "fully_connected_1/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/biases:0 is illegal; using fully_connected_1/biases_0 instead.\n",
      "fully_connected_2/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/weights:0 is illegal; using fully_connected_2/weights_0 instead.\n",
      "fully_connected_2/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/biases:0 is illegal; using fully_connected_2/biases_0 instead.\n"
     ]
    }
   ],
   "source": [
    "#正则化对应的参数数权重\n",
    "l2_loss = tf.add_n([#add加和得到总的l2_loss\n",
    "    tf.nn.l2_loss(w)#l2正则\n",
    "    for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)#获得权重\n",
    "])\n",
    "\n",
    "for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES):\n",
    "    print(w.name)\n",
    "    tf.summary.histogram(w.name, w)\n",
    "#summary API 是在网络中训练时 对一些感兴趣的数值进行监控的作用 会把监控的结果以文件形式写到磁盘上\n",
    "#histogram API是对于矩阵\n",
    "#scalar API是应用于单个数值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 总损失 = loss损失+L2损失"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'total_loss:0' shape=() dtype=string>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_loss = cross_entropy_loss + 7e-5 * l2_loss#7e-5数l2损失的权重\n",
    "tf.summary.scalar('cross_entropy_loss',cross_entropy_loss)\n",
    "tf.summary.scalar('l2_loss',l2_loss)\n",
    "tf.summary.scalar('total_loss',total_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### tf.summary.scalar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 优化器-梯度下降"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.3).minimize(total_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 评估准确率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-17-3e496b4300ce>:3: arg_max (from tensorflow.python.ops.gen_math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `argmax` instead\n"
     ]
    }
   ],
   "source": [
    "#上面网络输出的是未经softmax激活的logits 因此在评估时要做一下softmax计算\n",
    "pred = tf.nn.softmax(logits)\n",
    "correct_pred = tf.equal(tf.argmax(y,1),tf.arg_max(logits,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred,tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#训练集一共55000 这里11000次 2个enpoch\n",
    "batch_size = 100\n",
    "trainig_step = 1100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### saver用于保存或恢复训练的模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#训练是在内存或者显存上面运行的 重启之后会丢失的 直接加载saver里面保存的参数就ok了不用去重新训练\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### summary.merge_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged = tf.summary.merge_all()#每次运行summary.merge_all都会从网络中去搜寻我们定义的summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.198008, the validation accuracy is 0.6974\n",
      "after 200 training steps, the loss is 0.140398, the validation accuracy is 0.889\n",
      "after 300 training steps, the loss is 0.0972335, the validation accuracy is 0.9052\n",
      "after 400 training steps, the loss is 0.0612819, the validation accuracy is 0.9288\n",
      "after 500 training steps, the loss is 0.0343662, the validation accuracy is 0.945\n",
      "after 600 training steps, the loss is 0.0322848, the validation accuracy is 0.9514\n",
      "after 700 training steps, the loss is 0.0612285, the validation accuracy is 0.9574\n",
      "after 800 training steps, the loss is 0.0467669, the validation accuracy is 0.958\n",
      "after 900 training steps, the loss is 0.0490474, the validation accuracy is 0.9598\n",
      "after 1000 training steps, the loss is 0.038644, the validation accuracy is 0.9622\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9638\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    #设置监听的数据保存的路径\n",
    "    writer = tf.summary.FileWriter(\"logs/\", sess.graph)\n",
    "    #初始化\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {x: mnist.validation.images,y: mnist.validation.labels,keep_prob: 1.0}\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels, keep_prob: 1.0}\n",
    "    #训练\n",
    "    for i in range(trainig_step):\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss, rs = sess.run(\n",
    "            [optimizer, cross_entropy_loss, merged],\n",
    "            feed_dict={x: xs,y: ys,keep_prob: 0.6})\n",
    "        #写入监听 \n",
    "        writer.add_summary(rs, i)\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率#使用验证集\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)#保存模型训练的参数\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率#使用测试集\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-1000\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f362657f0f0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')#获取之前保存的参数\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        \n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)#saver\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16],\n",
    "                keep_prob: 1.0\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(\n",
    "                np.argmax(mnist.test.labels[idx]), order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 对模型训练的整个流程的理解和描述： \n",
    "\n",
    "输入数据 从网络的输入层输入 经过卷积 池化 卷积 池化 全连接 全连接 全连接 的网络结构（l-net5) 实现前向传播\n",
    "\n",
    "通过目标函数（损失函数+l2损失） 求得前向输出与真实值之间的loss\n",
    "\n",
    "再通过梯度下降算法 对模型中各个参数梯度并且更新参数  达到优化模型的作用\n",
    "\n",
    "不断重复这个过程知道模型达到训练次数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### tensorboard图标的解读\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 损失：\n",
    "\n",
    "随着不断的学习\n",
    "\n",
    "total_loss\n",
    "\n",
    "cross_entropy_loss 不断减小\n",
    "\n",
    "l2_loss不断增加 ：代表模型不断的变得复杂"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./pic/tl.png\", width=400, heigth=240>\n",
    "<img src=\"./pic/cel.png\", width=400, heigth=240>\n",
    "<img src=\"./pic/l2l.png\", width=400, heigth=240>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 计算图\n",
    "\n",
    "计算图总体的来看 主要是我们搭建的网络结构的节点 是以名字命名的 边上的连接标注这 每层的类型：\n",
    "\n",
    "conv1-pool1-conv2-pool2-fc1-fc2-dropout-fc3 \n",
    "\n",
    "几乎每层都有计算梯度gredient节点 求l2损失计算 ：l2_loss 使用梯度下降算法：GredientDecent\n",
    "\n",
    "添加监听数据到summary：ADDN 保存模型参数：save\n",
    "\n",
    "reshape操作：reshape\n",
    "\n",
    "计算total_loss 计算交叉熵损失cross_entropy_loss\n",
    "\n",
    "相加add 平均mean 强制转换cast \n",
    "\n",
    "softmax计算：softmax\n",
    "\n",
    "equal计算：Equal 然后布尔类型\n",
    "\n",
    "乘法计算：mul\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./pic/tbg.png\", width=800, heigth=800>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
